#include <string.h>
#include <iostream>
#include <utility>
#include <vector>

namespace A
{
	//简版
	class string
	{
	private:
		char* _s;

	public:
		string()//无参构造
			:_s(new char('\0'))
		{
		}
		string(const char* str)//带参构造
			:_s(new char [strlen(str) + 1])
		{
			strcpy(_s, str);
		}

		void swap(string& str2)
		{
			std::swap(_s, str2._s);
		}
//三种拷贝构造，注意第三种是错的
		//1、拷贝构造
		string(const string& str)
		:	_s(new char[strlen(str._s) + 1])
		{
			strcpy(_s, str._s);
		}

		////2、拷贝构造
		//string(const string& str)
		//	: _s(nullptr)
		//{
		//	string tmp(str._s);//也对，注意这种
		//	swap(tmp);
		//}

		////3、拷贝构造
		//string(const string& str)
		//	: _s(nullptr)
		//{
		//	string tmp(str);//这里错了,swap的类型不匹配
		//	swap(tmp);
		//}

		////4、拷贝构造
		//string(const string& str)
		//	: _s(nullptr)
		//{
		//	
		//	swap(str);//str的类型不匹配
		//}




		

		

		/*string(string&& str)//错误写法
		{
			swap(str);
			return *this;//哪来的返回值
		}*/

		//string(string&& str)//移动构造
		//	:_s(new char[strlen(str._s) + 1])
		//{
		//	strcpy(_s, str._s);
		//}

		string(string&& str)//移动构造
			:_s(nullptr)
		{
			swap(str);

		}


		string& operator = (string str)//赋值重载
		{
			swap(str);
			return *this;
		}

		////traditional
		//string& operator = (const string& str)
		//{
		//	string tmp(str);
		//	swap(tmp);
		//	return *this;
		//}
		string& operator = (string&& str)//移动赋值,针对函数传值返回又构造string对象，可以优化至少一次拷贝构造中的深拷贝
		{
			swap(str);
			return *this;
		}

		size_t size()const
		{
			return strlen(_s);
		}

		const char* c_str()const
		{
			return _s;
		}

		~string()
		{
			delete[] _s;
			_s = nullptr;
		}


	};


	
}

A::string baz()
{
	A::string ret("world");
	return  ret;
}

int main()
{
	A::string s0;
	A::string s1("hello");
	A::string s2(s0);
	A::string s3 = s1;
	s2 = s1;

	std::vector<A::string> svec;
	svec.push_back(s0);
	svec.push_back(s1);
	svec.push_back(baz());
	svec.push_back("good job");
	

	return 0;
}
